package com.zzyl.common.core.domain; // 定义包路径，将该类归类到common模块的核心域包中

import java.io.Serializable; // 导入Serializable接口，用于支持对象序列化
import com.zzyl.common.constant.HttpStatus; // 导入HttpStatus常量类，用于定义HTTP状态码

// 导入Swagger相关注解
import io.swagger.annotations.ApiModel; // 导入Swagger模型注解，用于描述整个数据模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger模型属性注解，用于描述模型的各个属性

/**
 * 响应信息主体
 * 用于封装统一的API响应结果，包含状态码、消息和数据
 *
 * @author ruoyi
 */
@ApiModel(description = "响应信息主体") // Swagger注解，描述该实体类的作用
public class R<T> implements Serializable // 泛型类实现Serializable接口，支持序列化
{
    private static final long serialVersionUID = 1L; // 序列化版本标识符，用于序列化兼容性检查

    /** 成功 */
    public static final int SUCCESS = HttpStatus.SUCCESS; // 定义成功状态码，值为HttpStatus.SUCCESS

    /** 失败 */
    public static final int FAIL = HttpStatus.ERROR; // 定义失败状态码，值为HttpStatus.ERROR

    @ApiModelProperty(value = "状态码") // Swagger注解，描述状态码字段的含义
    private int code; // 声明状态码属性

    @ApiModelProperty(value = "消息内容") // Swagger注解，描述消息内容字段的含义
    private String msg; // 声明消息内容属性

    @ApiModelProperty(value = "响应数据") // Swagger注解，描述响应数据字段的含义
    private T data; // 声明响应数据属性，使用泛型T表示数据类型

    /**
     * 返回成功响应结果（无数据）
     * 
     * @return 成功响应结果
     */
    public static <T> R<T> ok() // 定义返回成功响应结果的静态方法（无数据）
    {
        return restResult(null, SUCCESS, "操作成功"); // 调用restResult方法构造成功响应结果
    }

    /**
     * 返回成功响应结果（带数据）
     * 
     * @param data 响应数据
     * @return 成功响应结果
     */
    public static <T> R<T> ok(T data) // 定义返回成功响应结果的静态方法（带数据）
    {
        return restResult(data, SUCCESS, "操作成功"); // 调用restResult方法构造成功响应结果
    }

    /**
     * 返回成功响应结果（带数据和消息）
     * 
     * @param data 响应数据
     * @param msg 消息内容
     * @return 成功响应结果
     */
    public static <T> R<T> ok(T data, String msg) // 定义返回成功响应结果的静态方法（带数据和消息）
    {
        return restResult(data, SUCCESS, msg); // 调用restResult方法构造成功响应结果
    }

    /**
     * 返回失败响应结果（无数据）
     * 
     * @return 失败响应结果
     */
    public static <T> R<T> fail() // 定义返回失败响应结果的静态方法（无数据）
    {
        return restResult(null, FAIL, "操作失败"); // 调用restResult方法构造失败响应结果
    }

    /**
     * 返回失败响应结果（带消息）
     * 
     * @param msg 消息内容
     * @return 失败响应结果
     */
    public static <T> R<T> fail(String msg) // 定义返回失败响应结果的静态方法（带消息）
    {
        return restResult(null, FAIL, msg); // 调用restResult方法构造失败响应结果
    }

    /**
     * 返回失败响应结果（带数据）
     * 
     * @param data 响应数据
     * @return 失败响应结果
     */
    public static <T> R<T> fail(T data) // 定义返回失败响应结果的静态方法（带数据）
    {
        return restResult(data, FAIL, "操作失败"); // 调用restResult方法构造失败响应结果
    }

    /**
     * 返回失败响应结果（带数据和消息）
     * 
     * @param data 响应数据
     * @param msg 消息内容
     * @return 失败响应结果
     */
    public static <T> R<T> fail(T data, String msg) // 定义返回失败响应结果的静态方法（带数据和消息）
    {
        return restResult(data, FAIL, msg); // 调用restResult方法构造失败响应结果
    }

    /**
     * 返回自定义状态码的响应结果
     * 
     * @param code 状态码
     * @param msg 消息内容
     * @return 响应结果
     */
    public static <T> R<T> fail(int code, String msg) // 定义返回自定义状态码响应结果的静态方法
    {
        return restResult(null, code, msg); // 调用restResult方法构造自定义响应结果
    }

    /**
     * 构造响应结果的私有静态方法
     * 
     * @param data 响应数据
     * @param code 状态码
     * @param msg 消息内容
     * @return 响应结果
     */
    private static <T> R<T> restResult(T data, int code, String msg) // 定义构造响应结果的私有静态方法
    {
        R<T> apiResult = new R<>(); // 创建R对象实例
        apiResult.setCode(code); // 设置状态码
        apiResult.setData(data); // 设置响应数据
        apiResult.setMsg(msg); // 设置消息内容
        return apiResult; // 返回构造的响应结果
    }

    // 以下为各属性的getter和setter方法
    public int getCode() // 获取状态码的方法
    {
        return code;
    }

    public void setCode(int code) // 设置状态码的方法
    {
        this.code = code;
    }

    public String getMsg() // 获取消息内容的方法
    {
        return msg;
    }

    public void setMsg(String msg) // 设置消息内容的方法
    {
        this.msg = msg;
    }

    public T getData() // 获取响应数据的方法
    {
        return data;
    }

    public void setData(T data) // 设置响应数据的方法
    {
        this.data = data;
    }

    /**
     * 判断响应结果是否为错误
     * 
     * @param ret 响应结果
     * @return 是否为错误
     */
    public static <T> Boolean isError(R<T> ret) // 定义判断响应结果是否为错误的静态方法
    {
        return !isSuccess(ret); // 返回与isSuccess相反的结果
    }

    /**
     * 判断响应结果是否为成功
     * 
     * @param ret 响应结果
     * @return 是否为成功
     */
    public static <T> Boolean isSuccess(R<T> ret) // 定义判断响应结果是否为成功的静态方法
    {
        return R.SUCCESS == ret.getCode(); // 判断状态码是否为成功状态码
    }
}